{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 一. 基础作业：给出代码的运行log截图并提供心得体会文档描述对整个模型构建及训练过程的理解。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 代码的运行log具体在下面给出，这次模型的构建和之前的感知机有点相似。采用的是全连接的方式，用的relu激活函数，通过计算交叉熵损失，并使用GradientDescentOptimizer 类优化器去实现梯度下降算法的优化。在训练过程中，新建了session并且按照分批batch_size和训练的次数trainig_step进行训练。在下述代码前的标注中，我也具体查询并且详细记录了每一个不懂的函数的作用以及参数的使用"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 二. 进阶作业：给出代码的运行log截图并提供心得体会文档描述对整个模型构建及训练过程的理解。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 本次作业是和图片相关的，下面代码中使用卷积连接的方式相对性能会更好一些，但是比较耗电脑的资源。硬件满足的情况下，能较快的在验证集上面到达98%以上的正确率。\n",
    "#### 我在全连接方式下进行一下参数的调整，只需将batch_size = 50，trainig_step = 10000，即可得到所需要的结果：将验证集上面的正确率提高到98%以上。同时我测试了将隐层从单隐层变化到5个隐层，其中单隐层/双隐层效果不错，单纯的提高隐层的层数不能提高模型的性能。同样的测试了神经元个数，在单/双隐层下，50-150个神经元有比较好的效果，L2正则相对L1正则效果较好，初始值的时候，改变了正态分布的均值影响不大，但是改变标准差的时候，影响很大，应该遵守2/n的原则。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "tf.logging.set_verbosity(tf.logging.INFO)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 数据的下载和导入需要在Python安装目录下面:\n",
    "#### Programs\\Python\\Python36\\Lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\n",
    "#### 修改mnist.py文件中的 DEFAULT_SOURCE_URL = 'http://yann.lecun.com/exdb/mnist/'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. 数据下载，导入，并查看训练集，验证集和测试集数量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-2-a065adcc686d>:1: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From c:\\users\\jack-pc\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From c:\\users\\jack-pc\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./MNIST/train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From c:\\users\\jack-pc\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./MNIST/train-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From c:\\users\\jack-pc\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.one_hot on tensors.\n",
      "Extracting ./MNIST/t10k-images-idx3-ubyte.gz\n",
      "Extracting ./MNIST/t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From c:\\users\\jack-pc\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "Extracting ./MNIST/train-images-idx3-ubyte.gz\n",
      "Extracting ./MNIST/train-labels-idx1-ubyte.gz\n",
      "Extracting ./MNIST/t10k-images-idx3-ubyte.gz\n",
      "Extracting ./MNIST/t10k-labels-idx1-ubyte.gz\n",
      "(55000, 784)\n",
      "(55000, 10)\n",
      "(5000, 784)\n",
      "(5000, 10)\n",
      "(10000, 784)\n",
      "(10000, 10)\n"
     ]
    }
   ],
   "source": [
    "mnist = input_data.read_data_sets(\"./MNIST/\", one_hot=True)\n",
    "mnist2 = input_data.read_data_sets(\"./MNIST/\")\n",
    "\n",
    "print(mnist.train.images.shape)\n",
    "print(mnist.train.labels.shape)\n",
    "\n",
    "print(mnist.validation.images.shape)\n",
    "print(mnist.validation.labels.shape)\n",
    "\n",
    "print(mnist.test.images.shape)\n",
    "print(mnist.test.labels.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.可视化，以便查看数据内容"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8,8))\n",
    "\n",
    "for idx in range(16):\n",
    "    plt.subplot(4,4, idx+1)\n",
    "    plt.axis('off')\n",
    "    plt.title('[{}]'.format(mnist.train.labels[idx]))\n",
    "    plt.imshow(mnist.train.images[idx].reshape((28,28)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  函数 tf.placeholder(dtype, shape=None, name=None) 解释：\n",
    "#####  dtype：数据类型。常用的是tf.float32,tf.float64等数值类型 ；\n",
    "##### shape：数据形状。默认是None，就是一维值，也可以是多维，比如[2,3], [None, 3]表示列是3，行不定； "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.定义计算图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tf.placeholder(\"float\", [None, 784])\n",
    "y = tf.placeholder(\"int64\", [None])\n",
    "y_ = tf.placeholder(tf.float32, [None, 10])\n",
    "learning_rate = tf.placeholder(\"float\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 函数 tf.truncated_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None) ：从截断的正态分布中输出随机值。生成的值服从具有指定平均值和标准偏差的正态分布，如果生成的值大于平均值2个标准偏差的值则丢弃重新选择。\n",
    "#####  shape: 一维的张量，也是输出的张量。  mean: 正态分布的均值。 stddev: 正态分布的标准差。 dtype: 输出的类型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize(shape, stddev=0.1):  #  , mean = 1\n",
    "  return tf.truncated_normal(shape, stddev=0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def weight_variable(shape):\n",
    "    initial = tf.truncated_normal(shape,stddev = 0.1)\n",
    "    return tf.Variable(initial)\n",
    "def bias_variable(shape):\n",
    "    initial = tf.constant(0.1,shape = shape)\n",
    "    return tf.Variable(initial)\n",
    "def conv2d(x,W):\n",
    "    return tf.nn.conv2d(x, W, strides = [1,1,1,1], padding = 'SAME')\n",
    "def max_pool_2x2(x):\n",
    "    return tf.nn.max_pool(x, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 定义卷积连接计算图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#ita = 0.09\n",
    "\n",
    "W_conv1 = weight_variable([5, 5, 1, 32])\n",
    "b_conv1 = bias_variable([32])\n",
    "\n",
    "x_image = tf.reshape(x,[-1,28,28,1])\n",
    "\n",
    "h_conv1 = tf.nn.relu(conv2d(x_image,W_conv1) + b_conv1)\n",
    "h_pool1 = max_pool_2x2(h_conv1)\n",
    "\n",
    "W_conv2 = weight_variable([5, 5, 32, 64])\n",
    "b_conv2 = bias_variable([64])\n",
    "\n",
    "h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)\n",
    "h_pool2 = max_pool_2x2(h_conv2)\n",
    "\n",
    "W_fc1 = weight_variable([7 * 7 * 64, 1024])\n",
    "b_fc1 = bias_variable([1024])\n",
    "\n",
    "h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])\n",
    "h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)\n",
    "\n",
    "keep_prob = tf.placeholder(\"float\")\n",
    "h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)\n",
    "\n",
    "W_fc2 = weight_variable([1024, 10])\n",
    "b_fc2 = bias_variable([10])\n",
    "\n",
    "y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)\n",
    "\n",
    "cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv))\n",
    "train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)\n",
    "correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))\n",
    "\n",
    "saver = tf.train.Saver() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 定义全连接计算图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "ita = 0.09\n",
    "\n",
    "L1_units_count = 100\n",
    "\n",
    "W_1 = tf.Variable(initialize([784, L1_units_count]))\n",
    "b_1 = tf.Variable(initialize([L1_units_count]))\n",
    "logits_1 = tf.matmul(x, W_1) + ita * tf.reduce_sum(tf.square(W_1),0)  #### matmul：矩阵相乘\n",
    "output_1 = tf.nn.relu(logits_1)  ### Relu ： 激活函数 ReLu=max(0,x)\n",
    "\n",
    "L3_units_count = 50\n",
    "\n",
    "W_3 = tf.Variable(initialize([L1_units_count, L3_units_count]))\n",
    "b_3 = tf.Variable(initialize([L3_units_count]))\n",
    "logits_3 = tf.matmul(output_1, W_3)  + ita * tf.reduce_sum(tf.square(W_3),0) #### matmul：矩阵相乘\n",
    "output_3 = tf.nn.relu(logits_3)  ### Relu ： 激活函数 ReLu=max(0,x)\n",
    "'''\n",
    "L4_units_count = 20\n",
    "\n",
    "W_4 = tf.Variable(initialize([L3_units_count, L4_units_count]))\n",
    "b_4 = tf.Variable(initialize([L4_units_count]))\n",
    "logits_4 = tf.matmul(output_3, W_4)  + ita * tf.reduce_sum(tf.square(W_4),0) #### matmul：矩阵相乘\n",
    "output_4 = tf.nn.relu(logits_4)  ### Relu ： 激活函数 ReLu=max(0,x)\n",
    "\n",
    "L5_units_count = 20\n",
    "\n",
    "W_5 = tf.Variable(initialize([L4_units_count, L5_units_count]))\n",
    "b_5 = tf.Variable(initialize([L5_units_count]))\n",
    "logits_5 = tf.matmul(output_4, W_5)  + ita * tf.reduce_sum(tf.square(W_5),0) #### matmul：矩阵相乘\n",
    "output_5 = tf.nn.relu(logits_5)  ### Relu ： 激活函数 ReLu=max(0,x)\n",
    "\n",
    "L6_units_count = 40\n",
    "\n",
    "W_6 = tf.Variable(initialize([L5_units_count, L6_units_count]))\n",
    "b_6 = tf.Variable(initialize([L6_units_count]))\n",
    "logits_6 = tf.matmul(output_5, W_6)  + ita * tf.reduce_sum(tf.square(W_6),0) #### matmul：矩阵相乘\n",
    "output_6 = tf.nn.relu(logits_6)  ### Relu ： 激活函数 ReLu=max(0,x)\n",
    "\n",
    "L7_units_count = 20\n",
    "\n",
    "W_7 = tf.Variable(initialize([L6_units_count, L7_units_count]))\n",
    "b_7 = tf.Variable(initialize([L7_units_count]))\n",
    "logits_7 = tf.matmul(output_6, W_7)  + ita * tf.reduce_sum(tf.square(W_7),0) #### matmul：矩阵相乘\n",
    "output_7 = tf.nn.relu(logits_7)  ### Relu ： 激活函数 ReLu=max(0,x)\n",
    "'''\n",
    "\n",
    "L2_units_count = 10\n",
    "W_2 = tf.Variable(initialize([L3_units_count, L2_units_count]))\n",
    "b_2 = tf.Variable(initialize([L2_units_count]))\n",
    "logits_2 = tf.matmul(output_3, W_2)  + ita * tf.reduce_sum(tf.square(W_2),0)\n",
    "\n",
    "logits = logits_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 函数 tf.nn.softmax_cross_entropy_with_logits（logits= , labels=）计算交叉熵\n",
    "#### logits为神经网络输出层的输出，shape为[batch_size，num_classes]，\n",
    "#### label为一个一维的vector，长度等于batch_size，每一个值的取值区间必须是[0，num_classes)，其实每一个值就是代表了batch中对应样本的类别"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### tf.reduce_mean函数的作用是求平均值。第一个参数是一个集合，可以是列表、二维数组和多维数组。第二个参数指定在哪个维度上面求平均值。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### tf.train.GradientDescentOptimizer  实现梯度下降算法的优化器的类\n",
    "#### __init__(learning_rate, use_locking=False,name=’GradientDescent’)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "cross_entropy_loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=y))\n",
    "\n",
    "#optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(cross_entropy_loss)\n",
    "\n",
    "optimizer = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy_loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 函数 tf.nn.softmax 相当于： softmax = tf.exp(logits) / tf.reduce_sum(tf.exp(logits), axis)\n",
    "#### 函数 tf.argmax 相当于：np.argmax\n",
    "#### 函数 tf.equal(x, y, name=None) : 对x,y中的逐个元素进行判断，如果相等就是True，不相等，就是False。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred = tf.nn.softmax(logits)\n",
    "correct_pred = tf.equal(tf.argmax(pred, 1), y)\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.创建并运行Session "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1 创建并运行卷积连接的Session "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 0, training accuracy 0.12 ,validation accuracy is 0.1008\n",
      "step 100, training accuracy 0.86 ,validation accuracy is 0.8502\n",
      "step 200, training accuracy 0.94 ,validation accuracy is 0.9106\n",
      "step 300, training accuracy 0.96 ,validation accuracy is 0.929\n",
      "step 400, training accuracy 0.98 ,validation accuracy is 0.9364\n",
      "step 500, training accuracy 0.9 ,validation accuracy is 0.9458\n",
      "step 600, training accuracy 0.94 ,validation accuracy is 0.9516\n",
      "step 700, training accuracy 0.92 ,validation accuracy is 0.9576\n",
      "step 800, training accuracy 0.96 ,validation accuracy is 0.9616\n",
      "step 900, training accuracy 0.98 ,validation accuracy is 0.9636\n",
      "step 1000, training accuracy 0.94 ,validation accuracy is 0.966\n",
      "step 1100, training accuracy 0.98 ,validation accuracy is 0.9672\n",
      "step 1200, training accuracy 0.94 ,validation accuracy is 0.9686\n",
      "step 1300, training accuracy 0.96 ,validation accuracy is 0.9698\n",
      "step 1400, training accuracy 0.88 ,validation accuracy is 0.971\n",
      "step 1500, training accuracy 1 ,validation accuracy is 0.9716\n",
      "step 1600, training accuracy 1 ,validation accuracy is 0.9746\n",
      "step 1700, training accuracy 0.98 ,validation accuracy is 0.9716\n",
      "step 1800, training accuracy 0.98 ,validation accuracy is 0.973\n",
      "step 1900, training accuracy 0.96 ,validation accuracy is 0.9746\n",
      "step 2000, training accuracy 0.96 ,validation accuracy is 0.976\n",
      "step 2100, training accuracy 0.96 ,validation accuracy is 0.978\n",
      "step 2200, training accuracy 0.92 ,validation accuracy is 0.9782\n",
      "step 2300, training accuracy 0.98 ,validation accuracy is 0.9792\n",
      "step 2400, training accuracy 1 ,validation accuracy is 0.9796\n",
      "step 2500, training accuracy 0.98 ,validation accuracy is 0.9806\n",
      "step 2500, training accuracy 0.98 ,validation accuracy is 0.9806\n",
      "test accuracy 0.9764\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    for i in range(5000):\n",
    "        batch = mnist.train.next_batch(50)\n",
    "        if i % 100 == 0:\n",
    "            train_accuracy = accuracy.eval(feed_dict={x: batch[0], y_: batch[1], keep_prob: 1.0})\n",
    "            validation_accuracy = accuracy.eval(feed_dict={x: mnist.validation.images, y_: mnist.validation.labels, keep_prob: 1.0})\n",
    "            print('step %d, training accuracy %g ,validation accuracy is %g' % (i, train_accuracy, validation_accuracy))\n",
    "            if validation_accuracy > 0.98:\n",
    "                print('step %d, training accuracy %g ,validation accuracy is %g' % (i, train_accuracy, validation_accuracy))\n",
    "                break\n",
    "        train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})\n",
    "    saver.save(sess, './model.ckpt')\n",
    "    \n",
    "    print('test accuracy %g' % accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### sess.run(tf.global_variables_initializer()) 初始化变量"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 创建并运行全连接的Session"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 50\n",
    "trainig_step = 40000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after 0 training steps, the loss is 2.45121, the validation accuracy is 0.11\n",
      "after 500 training steps, the loss is 0.702907, the validation accuracy is 0.8376\n",
      "after 1000 training steps, the loss is 0.455345, the validation accuracy is 0.8914\n",
      "after 1500 training steps, the loss is 0.518843, the validation accuracy is 0.9058\n",
      "after 2000 training steps, the loss is 0.225907, the validation accuracy is 0.9142\n",
      "after 2500 training steps, the loss is 0.268714, the validation accuracy is 0.9186\n",
      "after 3000 training steps, the loss is 0.257648, the validation accuracy is 0.9242\n",
      "after 3500 training steps, the loss is 0.342425, the validation accuracy is 0.93\n",
      "after 4000 training steps, the loss is 0.460577, the validation accuracy is 0.93\n",
      "after 4500 training steps, the loss is 0.13913, the validation accuracy is 0.9352\n",
      "after 5000 training steps, the loss is 0.302786, the validation accuracy is 0.9364\n",
      "after 5500 training steps, the loss is 0.188366, the validation accuracy is 0.9406\n",
      "after 6000 training steps, the loss is 0.127055, the validation accuracy is 0.9402\n",
      "after 6500 training steps, the loss is 0.257401, the validation accuracy is 0.9446\n",
      "after 7000 training steps, the loss is 0.383903, the validation accuracy is 0.9448\n",
      "after 7500 training steps, the loss is 0.415739, the validation accuracy is 0.9466\n",
      "after 8000 training steps, the loss is 0.238392, the validation accuracy is 0.9484\n",
      "after 8500 training steps, the loss is 0.07085, the validation accuracy is 0.9494\n",
      "after 9000 training steps, the loss is 0.199183, the validation accuracy is 0.9544\n",
      "after 9500 training steps, the loss is 0.0797411, the validation accuracy is 0.9524\n",
      "after 10000 training steps, the loss is 0.237001, the validation accuracy is 0.9558\n",
      "after 10500 training steps, the loss is 0.139749, the validation accuracy is 0.9566\n",
      "after 11000 training steps, the loss is 0.0983097, the validation accuracy is 0.9576\n",
      "after 11500 training steps, the loss is 0.182718, the validation accuracy is 0.9598\n",
      "after 12000 training steps, the loss is 0.0342, the validation accuracy is 0.9596\n",
      "after 12500 training steps, the loss is 0.0805096, the validation accuracy is 0.9584\n",
      "after 13000 training steps, the loss is 0.201099, the validation accuracy is 0.962\n",
      "after 13500 training steps, the loss is 0.0980608, the validation accuracy is 0.963\n",
      "after 14000 training steps, the loss is 0.148177, the validation accuracy is 0.9628\n",
      "after 14500 training steps, the loss is 0.23181, the validation accuracy is 0.9644\n",
      "after 15000 training steps, the loss is 0.0999366, the validation accuracy is 0.9638\n",
      "after 15500 training steps, the loss is 0.14733, the validation accuracy is 0.965\n",
      "after 16000 training steps, the loss is 0.186076, the validation accuracy is 0.9636\n",
      "after 16500 training steps, the loss is 0.0282704, the validation accuracy is 0.967\n",
      "after 17000 training steps, the loss is 0.231103, the validation accuracy is 0.9658\n",
      "after 17500 training steps, the loss is 0.0559685, the validation accuracy is 0.9676\n",
      "after 18000 training steps, the loss is 0.0812699, the validation accuracy is 0.967\n",
      "after 18500 training steps, the loss is 0.0318768, the validation accuracy is 0.9688\n",
      "after 19000 training steps, the loss is 0.0646309, the validation accuracy is 0.968\n",
      "after 19500 training steps, the loss is 0.132976, the validation accuracy is 0.969\n",
      "after 20000 training steps, the loss is 0.173326, the validation accuracy is 0.9694\n",
      "after 20500 training steps, the loss is 0.0366723, the validation accuracy is 0.9694\n",
      "after 21000 training steps, the loss is 0.066512, the validation accuracy is 0.969\n",
      "after 21500 training steps, the loss is 0.109539, the validation accuracy is 0.9702\n",
      "after 22000 training steps, the loss is 0.123903, the validation accuracy is 0.9712\n",
      "after 22500 training steps, the loss is 0.208016, the validation accuracy is 0.9708\n",
      "after 23000 training steps, the loss is 0.0641485, the validation accuracy is 0.9714\n",
      "after 23500 training steps, the loss is 0.0569843, the validation accuracy is 0.971\n",
      "after 24000 training steps, the loss is 0.0719298, the validation accuracy is 0.9712\n",
      "after 24500 training steps, the loss is 0.183722, the validation accuracy is 0.9714\n",
      "after 25000 training steps, the loss is 0.171638, the validation accuracy is 0.9712\n",
      "after 25500 training steps, the loss is 0.0724844, the validation accuracy is 0.974\n",
      "after 26000 training steps, the loss is 0.0444571, the validation accuracy is 0.9714\n",
      "after 26500 training steps, the loss is 0.0462508, the validation accuracy is 0.9724\n",
      "after 27000 training steps, the loss is 0.0513878, the validation accuracy is 0.9724\n",
      "after 27500 training steps, the loss is 0.0606855, the validation accuracy is 0.9718\n",
      "after 28000 training steps, the loss is 0.0721095, the validation accuracy is 0.972\n",
      "after 28500 training steps, the loss is 0.121907, the validation accuracy is 0.9746\n",
      "after 29000 training steps, the loss is 0.0761166, the validation accuracy is 0.972\n",
      "after 29500 training steps, the loss is 0.046385, the validation accuracy is 0.973\n",
      "after 30000 training steps, the loss is 0.0228588, the validation accuracy is 0.9726\n",
      "after 30500 training steps, the loss is 0.0207401, the validation accuracy is 0.9728\n",
      "after 31000 training steps, the loss is 0.10007, the validation accuracy is 0.9724\n",
      "after 31500 training steps, the loss is 0.0217348, the validation accuracy is 0.9732\n",
      "after 32000 training steps, the loss is 0.0837058, the validation accuracy is 0.9746\n",
      "after 32500 training steps, the loss is 0.0433806, the validation accuracy is 0.9736\n",
      "after 33000 training steps, the loss is 0.0442698, the validation accuracy is 0.974\n",
      "after 33500 training steps, the loss is 0.0155364, the validation accuracy is 0.9732\n",
      "after 34000 training steps, the loss is 0.154777, the validation accuracy is 0.9734\n",
      "after 34500 training steps, the loss is 0.0388611, the validation accuracy is 0.9762\n",
      "after 35000 training steps, the loss is 0.178424, the validation accuracy is 0.9748\n",
      "after 35500 training steps, the loss is 0.0190388, the validation accuracy is 0.9748\n",
      "after 36000 training steps, the loss is 0.0314775, the validation accuracy is 0.9738\n",
      "after 36500 training steps, the loss is 0.0619103, the validation accuracy is 0.974\n",
      "after 37000 training steps, the loss is 0.0405562, the validation accuracy is 0.975\n",
      "after 37500 training steps, the loss is 0.00866836, the validation accuracy is 0.9754\n",
      "after 38000 training steps, the loss is 0.0647073, the validation accuracy is 0.973\n",
      "after 38500 training steps, the loss is 0.0300668, the validation accuracy is 0.9756\n",
      "after 39000 training steps, the loss is 0.0833564, the validation accuracy is 0.9736\n",
      "after 39500 training steps, the loss is 0.0178068, the validation accuracy is 0.974\n",
      "the training is finish!\n",
      "the test accuarcy is: 0.9733\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "\n",
    "    #定义验证集与测试集\n",
    "    validate_data = {\n",
    "        x: mnist2.validation.images,\n",
    "        y: mnist2.validation.labels,\n",
    "    }\n",
    "    test_data = {x: mnist2.test.images, y: mnist2.test.labels}\n",
    "\n",
    "    for i in range(trainig_step):\n",
    "        xs, ys = mnist2.train.next_batch(batch_size)\n",
    "        _, loss = sess.run(\n",
    "            [optimizer, cross_entropy_loss],\n",
    "            feed_dict={\n",
    "                x: xs,\n",
    "                y: ys,\n",
    "                learning_rate: 0.3\n",
    "            })\n",
    "        #每100次训练打印一次损失值与验证准确率\n",
    "        #validate_accuracy = sess.run(accuracy, feed_dict=validate_data)\n",
    "        if i >= 0 and i % 500 == 0:\n",
    "            validate_accuracy = sess.run(accuracy, feed_dict=validate_data)\n",
    "            print(\n",
    "                \"after %d training steps, the loss is %g, the validation accuracy is %g\"\n",
    "                % (i, loss, validate_accuracy))\n",
    "            saver.save(sess, './model.ckpt', global_step=i)\n",
    "        \n",
    "        if validate_accuracy > 0.98:\n",
    "            print(\n",
    "                \"after %d training steps, the loss is %g, the validation accuracy is %g\"\n",
    "                % (i, loss, validate_accuracy))\n",
    "            saver.save(sess, './model.ckpt', global_step=i)\n",
    "            break\n",
    "    WW = sess.run(W_1)\n",
    "    print(\"the training is finish!\")\n",
    "    #WW = sess.run(W_1)\n",
    "    #最终的测试准确率\n",
    "    acc = sess.run(accuracy, feed_dict=test_data)\n",
    "    print(\"the test accuarcy is:\", acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.测试训练的模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from ./model.ckpt-4950\n",
      "0.875\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    ckpt = tf.train.get_checkpoint_state('./')\n",
    "    if ckpt and ckpt.model_checkpoint_path:\n",
    "        saver.restore(sess, ckpt.model_checkpoint_path)\n",
    "        final_pred, acc = sess.run(\n",
    "            [pred, accuracy],\n",
    "            feed_dict={\n",
    "                x: mnist.test.images[:16],\n",
    "                y: mnist.test.labels[:16]\n",
    "            })\n",
    "        orders = np.argsort(final_pred)\n",
    "        plt.figure(figsize=(8, 8))\n",
    "        print(acc)\n",
    "        for idx in range(16):\n",
    "            order = orders[idx, :][-1]\n",
    "            prob = final_pred[idx, :][order]\n",
    "            plt.subplot(4, 4, idx + 1)\n",
    "            plt.axis('off')\n",
    "            plt.title('{}: [{}]-[{:.1f}%]'.format(mnist.test.labels[idx],\n",
    "                                                  order, prob * 100))\n",
    "            plt.imshow(mnist.test.images[idx].reshape((28, 28)))\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "WW2 = tf.Variable(WW)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-8.5152820e-02  1.3878512e-01  1.3259113e-03 ... -9.9817105e-02\n",
      "   3.7949043e-04 -3.3461332e-01]\n",
      " [-1.6148943e-03 -2.8954199e-01 -5.4986700e-02 ... -1.2415735e-01\n",
      "  -5.5068004e-01  5.4776740e-01]\n",
      " [ 2.5407395e-01  1.4373806e-03 -1.2675928e-01 ...  1.6776476e-02\n",
      "   1.9388120e-01 -4.0572885e-02]\n",
      " ...\n",
      " [-2.5605610e-01  1.1153191e-01  1.2341104e-02 ...  1.6522976e-02\n",
      "  -3.2958910e-01 -2.9854244e-01]\n",
      " [-1.4234805e-03 -1.1831765e-01  4.9684192e-03 ...  2.7935710e-02\n",
      "  -1.5107149e-02  2.7229351e-01]\n",
      " [-2.9290357e-01 -4.3295186e-02 -5.6746924e-01 ... -1.8892638e-02\n",
      "   1.4592071e-01 -2.1163973e-01]]\n",
      "[2.0239296 2.1120963 2.3975236 2.0974839 2.0990777 2.556865  2.2047577\n",
      " 2.3370512 1.9648314 2.181137  2.5126593 2.43367   2.2224402 2.09306\n",
      " 2.1389036 2.5391078 2.087027  2.1787724 2.156653  2.2849753 2.3813906\n",
      " 2.1692357 2.0590346 2.357773  2.3279397 2.1484406 2.21897   2.1719408\n",
      " 2.1931217 2.1347961 2.1933343 2.258606  2.0117536 2.225962  2.110542\n",
      " 2.2145061 2.1817338 2.1373682 2.2876854 2.5595963 2.1225405 2.1415374\n",
      " 2.2348757 2.512363  2.1438262 2.5436528 2.0133548 2.1218386 2.0131185\n",
      " 2.243738  2.2671487 2.0993288 2.1249413 2.1065164 2.2694936 2.0753937\n",
      " 1.9814775 2.1299808 2.117115  2.3065298 2.327126  2.177535  2.732412\n",
      " 2.149758  2.2051945 2.126169  2.180368  2.1197906 2.56189   2.165592\n",
      " 2.1600194 2.228951  2.419509  2.0300848 2.1611183 1.9922558 2.2149704\n",
      " 2.2964225 2.28793   2.0075698 2.3069997 2.2645981 2.3036852 2.13849\n",
      " 2.2513978 2.3137536 2.089044  2.0320349 2.1288085 1.9939878 2.1514864\n",
      " 2.1461322 1.9933769 2.0913136 1.9995657 2.2602842 2.109968  2.3323667\n",
      " 2.3666928 2.099495  2.1306174 2.2282681 2.6424239 2.159498  2.1764686\n",
      " 2.204927  2.2004375 2.072065  2.1647975 1.9834876 2.0696132 2.1838422\n",
      " 1.9693675 2.1057646 2.1246576 2.0878828 2.1694214 2.304314  2.2140126\n",
      " 2.2761974 2.3744583 2.463431  2.22834   2.2532752 2.1324408 2.3024232\n",
      " 2.1177711 2.1684473 2.0516558 2.0765436 2.3320687 2.2067938 2.2581108\n",
      " 2.2879474 2.2377336 2.2370589 2.159187  2.0927873 2.333708  2.434682\n",
      " 2.3519006 2.3277519 2.0725374 1.9975889 2.085404  2.271088  2.1515818\n",
      " 2.135349  2.1121693 2.2177343 2.1285672 2.1232922 2.1976645 2.0559719\n",
      " 2.3999283 2.1745267 2.0617337 2.3638256 2.2879353 2.1516864 2.1396673\n",
      " 2.0446265 2.0364945 2.0943031 2.2849944 2.0819652 2.1995277 2.032322\n",
      " 2.223291  2.2142856 2.031909  2.0755148 2.0753536 1.9691955 2.1573448\n",
      " 2.2490091 2.074406  2.256441  2.22062   2.0589936 2.1815946 2.340702\n",
      " 2.082263  2.2985024 2.126856  2.3270612 1.9490674 2.066905  2.257877\n",
      " 2.2208214 2.202255  2.3158987 2.1045084 2.1690063 2.1953363 2.1485069\n",
      " 2.454255  2.4641755 2.1815228 2.0235999]\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    print(sess.run(WW2))\n",
    "    print(sess.run(0.04 * tf.reduce_sum(tf.square(WW2),0))) # tf.square  tf.abs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
